# load pretty jupyter's magics
%load_ext pretty_jupyter

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split,cross_val_predict,GridSearchCV
from sklearn.metrics import roc_curve,roc_auc_score,f1_score,recall_score,precision_score,accuracy_score
from sklearn.preprocessing import FunctionTransformer
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.naive_bayes import MultinomialNB, ComplementNB,GaussianNB 
from sklearn.ensemble import RandomForestClassifier 
from sklearn.neighbors import KNeighborsClassifier 
from sklearn.model_selection import cross_validate
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
import nltk
from sklearn.metrics import confusion_matrix
import seaborn as sns

# Download necessary NLTK resources
nltk.download('wordnet')

# Load dataset
suicide = pd.read_csv('./Suicide_Detection.csv',usecols=['text','class'])

suicide.head()

suicide[['class']].value_counts()

suicide['class'] = np.where(suicide['class']=='suicide',1,0)#converting label to numeric

suicide.shape

suicide.isna().sum()# Check for missing values

suicide['text'].duplicated().sum()#check for missing text

sample_suicide = suicide.iloc[:5000]# Reducing dataset for faster processing.

sample_suicide[['class']].value_counts()#Dataset is still balanced

# Labels and Features
y = sample_suicide['class']
X = sample_suicide.drop('class',axis=1)

#Split dataset into train and test
X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=.2,random_state=42)

def preprocess_text(text):
    """Tokenizes, lowercases, removes stop words, lemmatizes, and removes non-alphabetic tokens."""
    lemmatizer = WordNetLemmatizer()
    tokens = word_tokenize(text.lower())
    preprocessed_text = ' '.join([lemmatizer.lemmatize(word) for word in tokens if word.isalpha()])
    return preprocessed_text

text_preprocessor = FunctionTransformer(lambda X: [preprocess_text(t) for t in X], validate=False)

# Combine text preprocessing and vectorization into a pipeline
text_processing_pipeline = Pipeline([
    ('preprocessing', text_preprocessor), # Preprocessing step
    ('vectorization', TfidfVectorizer()) # TF-IDF vectorization
])

# Define the preprocessor for the whole dataset
preprocessor = ColumnTransformer(
    transformers=[
        ('text', text_processing_pipeline, 'text')  # Apply the combined pipeline only to the 'text' column
    ]
)

# Convert sparse to dense
dense_transformer = FunctionTransformer(lambda x: x.toarray(), accept_sparse=True)

# Define a generic pipeline (with no specific model yet)
generic_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('to_dense', None),
    ('model', None)  # Placeholder for model
])

# Define the model candidates
models = {
    'GaussianNB': GaussianNB(),
    'ComplementNB': ComplementNB(),
    'MultinomialNB': MultinomialNB(),
    'RandomForestClassifier':RandomForestClassifier(random_state=42),
    'KNeighborsClassifier':KNeighborsClassifier(),
}

def plot_roc_curve():
    plt.plot([0,1],[0,1],'k--')
    plt.xlim([0.0, 1.0])
    plt.ylim([0.0, 1.0])
    plt.xlabel('False Positive Rate')
    plt.ylabel('True Positive Rate (Recall)')
    plt.title('ROC Curve for Suicide Classification')

model_color_dict = {
    'GaussianNB':'red',
    'ComplementNB':'blue',
    'MultinomialNB':'green',
    'RandomForestClassifier':'yellow',
    'KNeighborsClassifier':'brown'
    }

scoring = ['accuracy','roc_auc', 'precision', 'recall', 'f1']

model_performance = pd.DataFrame()
plot_roc_curve()
# Loop through models and perform GridSearchCV for each one
for model_name, model in models.items():
    # Set the model in the pipeline
    generic_pipeline.set_params(model=model)
    if model_name == 'GaussianNB':
        generic_pipeline.set_params(to_dense=dense_transformer)
    else:
        generic_pipeline.set_params(to_dense=None)
    y_probas  = cross_val_predict(generic_pipeline,X_train,y_train,cv=3,method='predict_proba')[:,1]

    cv_results = cross_validate(generic_pipeline,X_train, y_train, cv=3, scoring=scoring)

    
    model_row = pd.DataFrame({
        'model_name':model_name,
        'AUV_score_mean': cv_results['test_roc_auc'].mean(),
        'AUV_score_std': cv_results['test_roc_auc'].std(),
        'Precision_mean': cv_results['test_precision'].mean(),
        'Precision_std': cv_results['test_precision'].std(),
        'Recall_mean': cv_results['test_recall'].mean(),
        'Recall_std': cv_results['test_recall'].std(),
        'F1_score_mean': cv_results['test_f1'].mean(),
        'F1_score_std': cv_results['test_f1'].std(),
        'Accuracy_mean': cv_results['test_accuracy'].mean(),
        'Accuracy_std': cv_results['test_accuracy'].std()
    },index=[0]
    )
    model_performance = pd.concat([model_performance,model_row])

    fpr_gnb,tpr_gnb,thresholds_gnb = roc_curve(y_train,y_probas)
    plt.plot(fpr_gnb,tpr_gnb,color = model_color_dict[model_name],label=model_name)


plt.legend(loc='lower right')
plt.show()

model_performance

# Set the model in the pipeline
generic_pipeline.set_params(model=ComplementNB())

generic_pipeline.set_params(to_dense=None)

y_train_pred = cross_val_predict(generic_pipeline,X_train,y_train,cv=3)

X_tp = X_train[(y_train == 1) & (y_train_pred == 1)]
X_fn = X_train[(y_train == 1) & (y_train_pred == 0)]
X_fp = X_train[(y_train == 0) & (y_train_pred == 1)]
X_tn = X_train[(y_train == 0) & (y_train_pred == 0)]

X_fp.head()

X_fp['text'].str.len().describe()

X_fn.head()

X_fn['text'].str.len().describe()

X_tp.head()

X_tp['text'].str.len().describe()

X_tn.head()

X_tn['text'].str.len().describe()

# Set the model in the pipeline
generic_pipeline.set_params(model=ComplementNB())

generic_pipeline.set_params(to_dense=None)
# Define the hyperparameter grid
param_grid = {
    'preprocessor__text__vectorization__ngram_range': [(1, 1), (1, 2),(1,3)],  # Tune n-gram range for TfidfVectorizer
    'preprocessor__text__vectorization__stop_words': [None,'english'],  # Tune stop_words for TfidfVectorizer
    'preprocessor__text__vectorization__max_df': [0.9, 1.0],  # Ignore very frequent words
    'preprocessor__text__vectorization__min_df': [1, 3],  # Ignore very rare words
    'preprocessor__text__vectorization__use_idf': [True, False],  # Use or ignore IDF
    'model__alpha': [0.1, 0.5, 1.0]  # Tune alpha for MultinomialNB
}


# Initialize Grid Search
grid_search = GridSearchCV(generic_pipeline, param_grid, cv=5,scoring='roc_auc')

# Fit and Evaluate
grid_search.fit(X_train, y_train)

# Print best parameters and score
print("Best parameters:", grid_search.best_params_)
print("Best score:", grid_search.best_score_)

y_pred = grid_search.predict(X_test)

print(f'''
      Model metrics:
      ROC AUC score: {roc_auc_score(y_test,y_pred):.2f}
      f1 score: {f1_score(y_test,y_pred):.2f}
      Recall score: {recall_score(y_test,y_pred):.2f}
      Precision score: {precision_score(y_test,y_pred):.2f}
      Accuracy score: {accuracy_score(y_test,y_pred):.2f}
'''
)

# Confusion matrix visualization
plt.figure(figsize=(6,4))
sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt='d', cmap='Blues')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()

examples_df = pd.DataFrame({
    'Category': ['Direct_and_Clear', 'Moderately_Subtle', 'Highly_Subtle', 'Noisy_and_Ambiguous', 'Noisy_with_External_Links'],
    'text': [
        "I don’t even know why I’m writing this. I guess I just feel like I need to get it out somehow. I’ve tried so hard to keep going, to find a reason to stay, but it feels like no matter what I do, nothing changes. I wake up every day feeling empty, exhausted, like I’m just going through the motions for everyone else’s sake. And honestly? I don’t think I can keep pretending anymore. I just want the pain to stop. I don’t see a way forward. Maybe this is my way of saying goodbye.",
        "Lately, I’ve been thinking a lot about how things used to be. How different life was, how much easier it felt. It’s funny how things change, how people drift apart, how you can be surrounded by so many and still feel completely alone. I don’t know, maybe I’m just tired. Maybe I just need a break from everything. It’s just… hard to see the point sometimes, you know? Anyway, I hope you’re all doing well. Take care of yourselves.",
        "You ever get that feeling like you’re standing at the edge of something? Not necessarily bad, just… different. Like maybe things are about to change, one way or another. I don’t know. Just been lost in my thoughts a lot lately. Hope everyone’s good.",
        "man idk wut it iz but sumtimez it feelz like no matter how much u try u jus keep fallin bak into the same place. u ever jus sit there n wonder if it even matterz anymore?? idk lol maybe im just trippin. anyway stay safe yall.",
        "yooo been thinkin a lot lately bout how sht workzz. weird how u can do evrything rite n still feel lyk u got nuthin left. idk mayb i jus need sum rest or wutevr. if any1 feelin like dis too check out www.ithinkimdone.net idk just a thought."
    ]
})

exmp_text = examples_df.drop('Category',axis=1)

examples_df['pred'] = grid_search.predict(exmp_text)
examples_df